// 导入PrismaClient和Next.js的NextRequest、NextResponse类型
import { PrismaClient } from "@prisma/client";
import { NextRequest, NextResponse } from "next/server";

// 定义请求参数的接口
interface RecordRequest {
    userId: string; // 用户的唯一标识
    topicId: string; // 主题的唯一标识
    choice?: string; // 用户的选择，POST请求中可能需要此字段，因此设为可选
}

// 初始化PrismaClient实例
const prisma = new PrismaClient();

// 定义处理GET请求的异步函数
export async function GET(request: NextRequest) {
    // 解析请求的URL参数
    const { searchParams } = new URL(request.url);
    const userId = searchParams.get("userId") ?? ""; // 获取userId参数，如果不存在则默认为空字符串
    const topicId = searchParams.get("topicId") ?? ""; // 获取topicId参数，如果不存在则默认为空字符串

    // 查询数据库中与给定userId和topicId匹配的记录
    const record = await prisma.record.findFirst({
        where: {
            userId,
            topicId
        }
    });

    // 如果没有找到匹配的记录，返回400错误
    if (!record) {
        return NextResponse.json({
            message: "无法找到投票记录,请重试！"
        }, { status: 400 });
    }

    // 如果找到记录，返回该记录及200状态码
    return NextResponse.json({ record }, { status: 200 });
}

// 更新选项值的异步函数
async function updateOptionValue(prisma: PrismaClient, optionId: string, increment: number) {
    // 更新指定id的选项值，根据increment的值增加或减少
    await prisma.option.update({
        where: {
            id: optionId
        },
        data: {
            value: {
                increment: increment // 使用Prisma的increment操作来更新值
            }
        }
    });
}

// ... (GET函数保持不变)

// 定义处理POST请求的异步函数
export async function POST(request: NextRequest) {
    try {
        // 解析请求体中的JSON数据
        const data = (await request.json()) as RecordRequest;
        const { userId, topicId, choice } = data;

        // 检查请求参数是否完整
        if (!userId || !topicId || !choice) {
            return NextResponse.json({
                message: "请求失败"
            }, { status: 400 });
        }

        let record; // 声明一个变量用于存储新创建的记录

        await prisma.$transaction(async (txnPrisma) => {
            // 查询数据库中与给定userId和topicId匹配的旧记录
            const oldRecord = await txnPrisma.record.findFirst({
                where: {
                    topicId,
                    userId
                }
            });

            // 查询主题信息
            const topic = await txnPrisma.topic.findUnique({
                where: {
                    id: topicId
                },
                include: {
                    options: true
                }
            });

            // 如果存在旧记录
            if (oldRecord) {
                // 找到旧记录对应的选项并更新其值
                const selectedOption = topic?.options.find(
                    option => option.key === oldRecord.choice
                );
                if (selectedOption) {
                    await updateOptionValue(txnPrisma as PrismaClient, selectedOption.id, -1);
                }

                // 删除旧记录
                await txnPrisma.record.delete({
                    where: {
                        id: oldRecord.id
                    }
                });
            }

            // 找到用户新选择的选项并更新其值
            const newSelectedOption = topic?.options.find(
                option => option.key === choice
            );
            if (newSelectedOption) {
                await updateOptionValue(txnPrisma as PrismaClient, newSelectedOption.id, 1);
            }

            // 创建新的记录
            record = await txnPrisma.record.create({
                data: {
                    topicId,
                    userId,
                    choice
                }
            });
        });

        return NextResponse.json({
            record
        }, { status: 200 });
    } catch (e) {
        console.error("Error in POST request:", e);
        return NextResponse.json({
            message: "网络异常请重试"
        }, { status: 500 });
    }
}